home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Lib / toolbox / WWW_Suite.py < prev   
Text File  |  1996-03-20  |  14KB  |  412 lines
  1. """Suite WorldWideWeb suite, as defined in Spyglass spec.: 
  2. Level 1, version 1
  3.  
  4. Generated from flap:Programma's:Netscape 2.0b5 Folder:Netscape 2.0b5
  5. AETE/AEUT resource version 1/0, language 0, script 0
  6. """
  7.  
  8. import aetools
  9. import MacOS
  10.  
  11. _code = 'WWW!'
  12.  
  13. class WWW_Suite:
  14.  
  15.     _argmap_OpenURL = {
  16.         'to' : 'INTO',
  17.         'toWindow' : 'WIND',
  18.         'flags' : 'FLGS',
  19.         'post_data' : 'POST',
  20.         'post_type' : 'MIME',
  21.         'progressApp' : 'PROG',
  22.     }
  23.  
  24.     def OpenURL(self, _object, _attributes={}, **_arguments):
  25.         """OpenURL: Opens a URL. Allows for more options than GetURL event
  26.         Required argument: URL
  27.         Keyword argument to: file destination
  28.         Keyword argument toWindow: window iD
  29.         Keyword argument flags: Binary: any combination of 1, 2 and 4 is allowed: 1 and 2 mean force reload the document. 4 is ignored
  30.         Keyword argument post_data: Form posting data
  31.         Keyword argument post_type: MIME type of the posting data. Defaults to application/x-www-form-urlencoded
  32.         Keyword argument progressApp: Application that will display progress
  33.         Keyword argument _attributes: AppleEvent attribute dictionary
  34.         Returns: ID of the loading window
  35.         """
  36.         _code = 'WWW!'
  37.         _subcode = 'OURL'
  38.  
  39.         aetools.keysubst(_arguments, self._argmap_OpenURL)
  40.         _arguments['----'] = _object
  41.  
  42.  
  43.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  44.                 _arguments, _attributes)
  45.         if _arguments.has_key('errn'):
  46.             raise MacOS.Error, aetools.decodeerror(_arguments)
  47.         # XXXX Optionally decode result
  48.         if _arguments.has_key('----'):
  49.             return _arguments['----']
  50.  
  51.     _argmap_ShowFile = {
  52.         'MIME_type' : 'MIME',
  53.         'Window_ID' : 'WIND',
  54.         'URL' : 'URL ',
  55.     }
  56.  
  57.     def ShowFile(self, _object, _attributes={}, **_arguments):
  58.         """ShowFile: Similar to OpenDocuments, except that it specifies the parent URL, and MIME type of the file
  59.         Required argument: File to open
  60.         Keyword argument MIME_type: MIME type
  61.         Keyword argument Window_ID: Window to open the file in
  62.         Keyword argument URL: Use this as a base URL
  63.         Keyword argument _attributes: AppleEvent attribute dictionary
  64.         Returns: Window ID of the loaded window. 0 means ShowFile failed, FFFFFFF means that data was not appropriate type to display in the browser.
  65.         """
  66.         _code = 'WWW!'
  67.         _subcode = 'SHWF'
  68.  
  69.         aetools.keysubst(_arguments, self._argmap_ShowFile)
  70.         _arguments['----'] = _object
  71.  
  72.  
  73.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  74.                 _arguments, _attributes)
  75.         if _arguments.has_key('errn'):
  76.             raise MacOS.Error, aetools.decodeerror(_arguments)
  77.         # XXXX Optionally decode result
  78.         if _arguments.has_key('----'):
  79.             return _arguments['----']
  80.  
  81.     _argmap_parse_anchor = {
  82.         'relative_to' : 'RELA',
  83.     }
  84.  
  85.     def parse_anchor(self, _object, _attributes={}, **_arguments):
  86.         """parse anchor: Resolves the relative URL
  87.         Required argument: Main URL
  88.         Keyword argument relative_to: Relative URL
  89.         Keyword argument _attributes: AppleEvent attribute dictionary
  90.         Returns: Parsed  URL
  91.         """
  92.         _code = 'WWW!'
  93.         _subcode = 'PRSA'
  94.  
  95.         aetools.keysubst(_arguments, self._argmap_parse_anchor)
  96.         _arguments['----'] = _object
  97.  
  98.  
  99.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  100.                 _arguments, _attributes)
  101.         if _arguments.has_key('errn'):
  102.             raise MacOS.Error, aetools.decodeerror(_arguments)
  103.         # XXXX Optionally decode result
  104.         if _arguments.has_key('----'):
  105.             return _arguments['----']
  106.  
  107.     _argmap_cancel_progress = {
  108.         'in_window' : 'WIND',
  109.     }
  110.  
  111.     def cancel_progress(self, _object=None, _attributes={}, **_arguments):
  112.         """cancel progress: Interrupts the download of the document in the given window
  113.         Required argument: progress ID, obtained from the progress app
  114.         Keyword argument in_window: window ID of the progress to cancel
  115.         Keyword argument _attributes: AppleEvent attribute dictionary
  116.         """
  117.         _code = 'WWW!'
  118.         _subcode = 'CNCL'
  119.  
  120.         aetools.keysubst(_arguments, self._argmap_cancel_progress)
  121.         _arguments['----'] = _object
  122.  
  123.  
  124.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  125.                 _arguments, _attributes)
  126.         if _arguments.has_key('errn'):
  127.             raise MacOS.Error, aetools.decodeerror(_arguments)
  128.         # XXXX Optionally decode result
  129.         if _arguments.has_key('----'):
  130.             return _arguments['----']
  131.  
  132.     def find_URL(self, _object, _attributes={}, **_arguments):
  133.         """find URL: If the file was downloaded by Netscape, you can call FindURL to find out the URL used to download the file.
  134.         Required argument: File spec
  135.         Keyword argument _attributes: AppleEvent attribute dictionary
  136.         Returns: The URL
  137.         """
  138.         _code = 'WWW!'
  139.         _subcode = 'FURL'
  140.  
  141.         if _arguments: raise TypeError, 'No optional args expected'
  142.         _arguments['----'] = _object
  143.  
  144.  
  145.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  146.                 _arguments, _attributes)
  147.         if _arguments.has_key('errn'):
  148.             raise MacOS.Error, aetools.decodeerror(_arguments)
  149.         # XXXX Optionally decode result
  150.         if _arguments.has_key('----'):
  151.             return _arguments['----']
  152.  
  153.     def webActivate(self, _object=None, _attributes={}, **_arguments):
  154.         """webActivate: Makes Netscape the frontmost application, and selects a given window. This event is here for suite completeness/ cross-platform compatibility only, you should use standard AppleEvents instead.
  155.         Required argument: window to bring to front
  156.         Keyword argument _attributes: AppleEvent attribute dictionary
  157.         """
  158.         _code = 'WWW!'
  159.         _subcode = 'ACTV'
  160.  
  161.         if _arguments: raise TypeError, 'No optional args expected'
  162.         _arguments['----'] = _object
  163.  
  164.  
  165.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  166.                 _arguments, _attributes)
  167.         if _arguments.has_key('errn'):
  168.             raise MacOS.Error, aetools.decodeerror(_arguments)
  169.         # XXXX Optionally decode result
  170.         if _arguments.has_key('----'):
  171.             return _arguments['----']
  172.  
  173.     def list_windows(self, _no_object=None, _attributes={}, **_arguments):
  174.         """list windows: Lists the IDs of all the hypertext windows
  175.         Keyword argument _attributes: AppleEvent attribute dictionary
  176.         Returns: List of unique IDs of all the hypertext windows
  177.         """
  178.         _code = 'WWW!'
  179.         _subcode = 'LSTW'
  180.  
  181.         if _arguments: raise TypeError, 'No optional args expected'
  182.         if _no_object != None: raise TypeError, 'No direct arg expected'
  183.  
  184.  
  185.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  186.                 _arguments, _attributes)
  187.         if _arguments.has_key('errn'):
  188.             raise MacOS.Error, aetools.decodeerror(_arguments)
  189.         # XXXX Optionally decode result
  190.         if _arguments.has_key('----'):
  191.             return _arguments['----']
  192.  
  193.     def get_window_info(self, _object=None, _attributes={}, **_arguments):
  194.         """get window info: Returns the information about the window as a list. Currently the list contains the window title and the URL. You can get the same information using standard Apple Event GetProperty.
  195.         Required argument: window ID
  196.         Keyword argument _attributes: AppleEvent attribute dictionary
  197.         Returns: undocumented, typecode 'list'
  198.         """
  199.         _code = 'WWW!'
  200.         _subcode = 'WNFO'
  201.  
  202.         if _arguments: raise TypeError, 'No optional args expected'
  203.         _arguments['----'] = _object
  204.  
  205.  
  206.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  207.                 _arguments, _attributes)
  208.         if _arguments.has_key('errn'):
  209.             raise MacOS.Error, aetools.decodeerror(_arguments)
  210.         # XXXX Optionally decode result
  211.         if _arguments.has_key('----'):
  212.             return _arguments['----']
  213.  
  214.     def register_URL_echo(self, _object=None, _attributes={}, **_arguments):
  215.         """register URL echo: Registers the ≥echo≤ application. Each download from now on will be echoed to this application.
  216.         Required argument: Application signature
  217.         Keyword argument _attributes: AppleEvent attribute dictionary
  218.         """
  219.         _code = 'WWW!'
  220.         _subcode = 'RGUE'
  221.  
  222.         if _arguments: raise TypeError, 'No optional args expected'
  223.         _arguments['----'] = _object
  224.  
  225.  
  226.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  227.                 _arguments, _attributes)
  228.         if _arguments.has_key('errn'):
  229.             raise MacOS.Error, aetools.decodeerror(_arguments)
  230.         # XXXX Optionally decode result
  231.         if _arguments.has_key('----'):
  232.             return _arguments['----']
  233.  
  234.     def unregister_URL_echo(self, _object, _attributes={}, **_arguments):
  235.         """unregister URL echo: cancels URL echo
  236.         Required argument: application signature
  237.         Keyword argument _attributes: AppleEvent attribute dictionary
  238.         """
  239.         _code = 'WWW!'
  240.         _subcode = 'UNRU'
  241.  
  242.         if _arguments: raise TypeError, 'No optional args expected'
  243.         _arguments['----'] = _object
  244.  
  245.  
  246.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  247.                 _arguments, _attributes)
  248.         if _arguments.has_key('errn'):
  249.             raise MacOS.Error, aetools.decodeerror(_arguments)
  250.         # XXXX Optionally decode result
  251.         if _arguments.has_key('----'):
  252.             return _arguments['----']
  253.  
  254.     _argmap_register_viewer = {
  255.         'MIME_type' : 'MIME',
  256.         'with_file_type' : 'FTYP',
  257.     }
  258.  
  259.     def register_viewer(self, _object, _attributes={}, **_arguments):
  260.         """register viewer: Registers an application as a åspecialπ viewer for this MIME type. The application will be launched with ViewDoc events
  261.         Required argument: Application sig
  262.         Keyword argument MIME_type: MIME type viewer is registering for
  263.         Keyword argument with_file_type: Mac file type for the downloaded files
  264.         Keyword argument _attributes: AppleEvent attribute dictionary
  265.         Returns: TRUE if registration has been successful
  266.         """
  267.         _code = 'WWW!'
  268.         _subcode = 'RGVW'
  269.  
  270.         aetools.keysubst(_arguments, self._argmap_register_viewer)
  271.         _arguments['----'] = _object
  272.  
  273.  
  274.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  275.                 _arguments, _attributes)
  276.         if _arguments.has_key('errn'):
  277.             raise MacOS.Error, aetools.decodeerror(_arguments)
  278.         # XXXX Optionally decode result
  279.         if _arguments.has_key('----'):
  280.             return _arguments['----']
  281.  
  282.     _argmap_unregister_viewer = {
  283.         'MIME_type' : 'MIME',
  284.     }
  285.  
  286.     def unregister_viewer(self, _object, _attributes={}, **_arguments):
  287.         """unregister viewer: Revert to the old way of handling this MIME type
  288.         Required argument: Application sig
  289.         Keyword argument MIME_type: MIME type to be unregistered
  290.         Keyword argument _attributes: AppleEvent attribute dictionary
  291.         Returns: TRUE if the event was successful
  292.         """
  293.         _code = 'WWW!'
  294.         _subcode = 'UNRV'
  295.  
  296.         aetools.keysubst(_arguments, self._argmap_unregister_viewer)
  297.         _arguments['----'] = _object
  298.  
  299.  
  300.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  301.                 _arguments, _attributes)
  302.         if _arguments.has_key('errn'):
  303.             raise MacOS.Error, aetools.decodeerror(_arguments)
  304.         # XXXX Optionally decode result
  305.         if _arguments.has_key('----'):
  306.             return _arguments['----']
  307.  
  308.     _argmap_register_protocol = {
  309.         'for_protocol' : 'PROT',
  310.     }
  311.  
  312.     def register_protocol(self, _object=None, _attributes={}, **_arguments):
  313.         """register protocol: Registers application as a ≥handler≤ for this protocol with a given prefix. The handler will receive ≥OpenURL≤, or if that fails, ≥GetURL≤ event.
  314.         Required argument: Application sig
  315.         Keyword argument for_protocol: protocol prefix: ≥finger:≤, ≥file≤,
  316.         Keyword argument _attributes: AppleEvent attribute dictionary
  317.         Returns: TRUE if registration has been successful
  318.         """
  319.         _code = 'WWW!'
  320.         _subcode = 'RGPR'
  321.  
  322.         aetools.keysubst(_arguments, self._argmap_register_protocol)
  323.         _arguments['----'] = _object
  324.  
  325.  
  326.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  327.                 _arguments, _attributes)
  328.         if _arguments.has_key('errn'):
  329.             raise MacOS.Error, aetools.decodeerror(_arguments)
  330.         # XXXX Optionally decode result
  331.         if _arguments.has_key('----'):
  332.             return _arguments['----']
  333.  
  334.     _argmap_unregister_protocol = {
  335.         'for_protocol' : 'PROT',
  336.     }
  337.  
  338.     def unregister_protocol(self, _object=None, _attributes={}, **_arguments):
  339.         """unregister protocol: reverses the effects of ≥register protocol≤
  340.         Required argument: Application sig. 
  341.         Keyword argument for_protocol: protocol prefix. If none, unregister for all protocols
  342.         Keyword argument _attributes: AppleEvent attribute dictionary
  343.         Returns: TRUE if successful
  344.         """
  345.         _code = 'WWW!'
  346.         _subcode = 'UNRP'
  347.  
  348.         aetools.keysubst(_arguments, self._argmap_unregister_protocol)
  349.         _arguments['----'] = _object
  350.  
  351.  
  352.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  353.                 _arguments, _attributes)
  354.         if _arguments.has_key('errn'):
  355.             raise MacOS.Error, aetools.decodeerror(_arguments)
  356.         # XXXX Optionally decode result
  357.         if _arguments.has_key('----'):
  358.             return _arguments['----']
  359.  
  360.     _argmap_register_window_close = {
  361.         'for_window' : 'WIND',
  362.     }
  363.  
  364.     def register_window_close(self, _object=None, _attributes={}, **_arguments):
  365.         """register window close: Netscape will notify registered application when this window closes
  366.         Required argument: Application signature
  367.         Keyword argument for_window: window ID
  368.         Keyword argument _attributes: AppleEvent attribute dictionary
  369.         Returns: true if successful
  370.         """
  371.         _code = 'WWW!'
  372.         _subcode = 'RGWC'
  373.  
  374.         aetools.keysubst(_arguments, self._argmap_register_window_close)
  375.         _arguments['----'] = _object
  376.  
  377.  
  378.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  379.                 _arguments, _attributes)
  380.         if _arguments.has_key('errn'):
  381.             raise MacOS.Error, aetools.decodeerror(_arguments)
  382.         # XXXX Optionally decode result
  383.         if _arguments.has_key('----'):
  384.             return _arguments['----']
  385.  
  386.     _argmap_unregister_window_close = {
  387.         'for_window' : 'WIND',
  388.     }
  389.  
  390.     def unregister_window_close(self, _object=None, _attributes={}, **_arguments):
  391.         """unregister window close: Undo for register window close
  392.         Required argument: Application signature
  393.         Keyword argument for_window: window ID
  394.         Keyword argument _attributes: AppleEvent attribute dictionary
  395.         Returns: true if successful
  396.         """
  397.         _code = 'WWW!'
  398.         _subcode = 'UNRC'
  399.  
  400.         aetools.keysubst(_arguments, self._argmap_unregister_window_close)
  401.         _arguments['----'] = _object
  402.  
  403.  
  404.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  405.                 _arguments, _attributes)
  406.         if _arguments.has_key('errn'):
  407.             raise MacOS.Error, aetools.decodeerror(_arguments)
  408.         # XXXX Optionally decode result
  409.         if _arguments.has_key('----'):
  410.             return _arguments['----']
  411.  
  412.